home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Demos / Eurochart31 / Articles / CoderCoursePart1 < prev    next >
Encoding:
Text File  |  1997-10-06  |  13.7 KB  |  531 lines
  1. »SML:»CL9:--------------------------------------
  2. »SML:»CL8:            »BIG:Coder's Course
  3. »SML:                »BIG:Part 1
  4. »SML:»CL9:--------------------------------------
  5. »CL4:           By Cytron/Depth
  6.  
  7. »CL0:OK, all you dear »CL1:"I've seen a lot of
  8. demos and want to code"»-sceners, I'm
  9. offering you a nice little
  10. assemblercourse for free. I guess that
  11. there are loads of those already, but
  12. as I learned coding pretty easy
  13. myself, I thought that my approach
  14. might be a good one. The approach is
  15. simply »CL1:getting into all the good sides
  16. of Amiga right away» - let the
  17. assembler do the understanding for you
  18. in the beginning, and just code
  19. something. And don't worry about
  20. copper, blitter, c2p, etc.. Just learn
  21. to control simple methods right away,
  22. and make a few small things that
  23. demomnstrate that 'I can do it', and
  24. makes you want to go further into it!
  25. ANYWAY, that was my appoach 6 months
  26. ago, and I've coded 3 demos already.
  27. Besides, I'm working on a 4k. So, this
  28. is what YOU can do in 3 months from
  29. now! Anyway, let's get started with...
  30.  
  31.   »CL8:The simple mathematical stuff,
  32.   that ALL sceners should know!:
  33. »SML:»CL1:Hexadeciaml representation:»CL0: When
  34. writing $FE it simply means 254,
  35. namely 16*$F+$E = 16*15+14=254.
  36.  
  37. »CL1:Signed/Unsigned:» When viewing at a
  38. number as signed, The most significant
  39. bit determines the sign.. If set, the
  40. number is negative and the number is
  41. all the other bits inverted plus 1.
  42. This is easier to see than to explain:
  43. eg., signed words:
  44.  
  45. »CL1:       $FE65 = -$019B = -   411
  46.        $3444 =  $3444 =   13380
  47.        $FF56 = -$00AA = -   170
  48.        $8645 = -$79BB = - 31163
  49.        $5634 =  $5634 =   22068
  50.        $0064 =  $0064 =     100
  51.        $C000 = -$4000 = - 16384
  52.        $FFFF = -$0001 = -     1
  53. »
  54.  
  55. »CL8:          »BIG:The registers:
  56. »SML:»CL9:--------------------------------------
  57. »CL0:The MC68xxx contains »CL1:16 registers, 8
  58. data- and 8 address-registers (d0-d7
  59. and a0-a7)». The difference between
  60. the two types of registers will be
  61.  
  62.  
  63.  
  64.  
  65. explained later in this chapter.
  66. From now on, aX will mean an
  67. addressregister and dX will mean a
  68. dataregister. The registers are
  69. 32-bit, simply meaning that a register
  70. contains 32 bits of data, that is up
  71. to $FFFFFFFF. When using commands
  72. that refer to registers, one has to
  73. specify which part of the register is
  74. being used. Let's look at the three
  75. ways of 'looking at' a register, 
  76. »CL1:eg. if d0 = $FE673C41, then
  77. d0 as longword is $FE673C41
  78. d0 as word     is     $3C41
  79. d0 as byte     is       $41
  80. »It's as simple as that!
  81. When using this principle in an
  82. assembler, one simply writes »CL1:d0.l»,
  83. »CL1:d0.w», or »CL1:d0.b» (Omitting this will      
  84. usually make the assembler             
  85.  
  86.                       »CL8:The basic instructions for this part: 
  87.                       »BIG:      move, add, sub, muls/mulu  
  88. »SML:»CL9:--------------------------------------------------------------------------------
  89. »CL0:All of these instructions have the following usage:
  90. »CL1:    command a,b  »CL0:      means do the command from a to b.
  91.  
  92. eg.»CL4: move.w  d1,d2 »CL5:   ; move the contents in d1 as word to d2 as word.
  93. »CL4:    add.b   d7,d0  »  ; add d7.b to d0.b. Please note that only the byte in
  94.                      ; d0 is affected, no matter what the result of the add is.
  95. »CL4:    sub.w   d0,a0  »  ; subtract d0 from a0. (Remeber to check the note
  96.                      ; about addressregisters later)
  97. »CL4:    mulu.w  d0,d0 »   ; multiply d0.w Unsigned with itself and put it in d0.l
  98.                      ; (this one is special, since we're multiplying) 
  99. »CL4:    muls.w  d3,d2 »   ; multiply d3.w with d2.w both viewed upon as SIGNED,
  100.                      ; and store the result in d2.l signed.
  101. »CL0:interpretate it as d0.w, but »CL1:PLEASE»
  102. get used to »CL1:ALWAYS» writing the
  103. extensions. The code get's easier to     
  104. grasp that way!)
  105.  
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.  
  121. »CL8:                   »BIG:Regarding address/dataregisters:»SML:
  122. »CL9:              -----------------------------------------------
  123. »CL0:Addressregisters are mainly used to    The simplest addressing modes:
  124. point onto some memory, not to perform When wanting to read/write from/to
  125. arithmetic instruction upon.           memory, the smartest approach is to
  126. Therefore, only add, sub and move      store the source/destination-address
  127. works with addressregisters.. And it's in an address-register, and then
  128. a little more complex than that. So,   writing to the memory from there. To
  129. for now, just leave the                demonstrate this, I'll make a little
  130. adressregisters when doing             example that will also show you the
  131. arithmetical instructions.             IMMEDIATE priciple:
  132.  
  133. »CL4:Start: move.l   #30,d0   »CL5:; Moves 30 into d0. d0 = $0000001E
  134. »CL4:       lea      Space,a0 »; Let a0 point at Space
  135. »CL4:       move.b   d0,(a0)  »; move d0 as byte into Space. Space = $1E000000
  136. »CL4:       move.w   d0,(a0)  »; move       d0 as word into Space. Space = $001E0000
  137. »CL4:       move.l   d0,(a0)  »; hehe...                     Space = $0000001E
  138. »CL4:       rts               »; Return to assembler
  139. »CL4:Space: dc.l     0        »; When this is assembled, Space = $00000000
  140.  
  141.  
  142.  
  143.  
  144.  
  145.  
  146.  
  147.  
  148.  
  149.  
  150.  
  151.  
  152.  
  153.  
  154.  
  155.  
  156.  
  157.  
  158.  
  159.  
  160.  
  161. »CL0:As you see, using »CL1:(aX)» means »CL1:AT» the
  162. address stored in aX.
  163. You might also mark that I've used an
  164. immidiate move. I've moved the number
  165. 30 into d0. »CL1:(You might wonder why I've
  166. moved as longword. The reason is that
  167. I clear the entire register, so that I
  168. know for sure that d0.l = $0000001E)»
  169.  
  170.   »CL8:»BIG:Let's start up our assembler:
  171. »CL9:»SML:--------------------------------------
  172. »CL0:It's time for you to experiment a
  173. little bit yourselves. Being in an
  174. assembler and watching what happens is
  175. the fastest way to learn anything. I
  176. will strongly recommend you to use
  177. »CL1:AsmOne 1.29», as this assembler is
  178. very straightforward and has a
  179. brilliant singlestepdebug feature
  180. (What a great word!). These examples
  181. apply for AsmOne 1.29. They might work
  182. in other assembler as well, but I
  183. wouldn't know!
  184.  
  185. Type the little program, I've made, in
  186. your assembler (Escape of course
  187. toggles between editing the source and
  188. controlling the whole thing). Now try
  189. this:
  190.  
  191. »CL2:a»
  192.  
  193. The thing should now assemble your
  194. code in hopefully report No Errors.
  195. When this is done, try typing
  196.  
  197. »CL2:h Space»
  198.  
  199.  
  200.  
  201. Now a lot of numbers should pop up at your screen. Like this:
  202.  
  203. »CL7:0822450C 00 00 00 00 12 34 56 78 01 01 00 00 00 08 00 00 ".....4Vx........"
  204. 0822451C 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "................"
  205. 0822452C 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "................"
  206. »CL0:^^^^^^^^ ^^                                               ^^^^^^^^^^^^^^^^
  207. Address  Data as Hex. Each line contains 16 bytes of data. Data as AscII
  208.  
  209. (Escape let's you out again)
  210. What we've just seen is the data at the label Space.
  211. If we change the line 
  212. »CL4:Space:       dc.l       0
  213. »to
  214. »CL4:Space:       dc.l       $CAFEBABE
  215. », our memory will (after assembling again) look like this:
  216.  
  217. »CL7:08224514 »CL6:CA FE BA BE» 12 34 56 78 01 01 00 00 00 08 00 00 "Êþº¾.4Vx........"
  218. 08224524 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "................"
  219. 08224534 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "................"
  220. »
  221.  
  222.  
  223.  
  224.  
  225.  
  226.  
  227.  
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239.  
  240.  
  241.  
  242.  
  243.  
  244.  
  245. »CL0:As you can see, The memory has now been changed.
  246. Now let's try writing:
  247.  
  248. »CL2:h Start
  249.  
  250. »CL7:08224500 20 3C 00 00 00 1E 41 F9 08 22 45 14 10 80 30 80 " <....Aù."E..`0`"
  251. 08224510 20 80 4E 75 CA FE BA BE 12 34 56 78 01 01 00 00 " `NuÊþº¾.4Vx...."
  252. 08224520 00 08 00 00 00 00 00 00 00 00 00 00 00 00 00 00 "................"
  253.  
  254. »CL0:Now, we're at another location in memory close to the other one (you can see
  255. CAFEBABE someplace!)
  256.  
  257.  
  258.  
  259.  
  260.  
  261.  
  262.  
  263.  
  264.  
  265.  
  266.  
  267.  
  268.  
  269.  
  270.  
  271.  
  272.  
  273.  
  274.  
  275.  
  276.  
  277.  
  278.  
  279.  
  280.  
  281. While we're in this HEX-viewer, try pressing »CL1:RAMIGA+d» (Disassemble).
  282.  
  283. Now we get:
  284.  
  285. »CL7:08224500 203C0000001E         MOVE.L      #$0000001E,D0
  286. 08224506 41F908224514         LEA         $08224514,A0
  287. 0822450C 1080                 MOVE.B      D0,(A0)
  288. 0822450E 3080                 MOVE.W      D0,(A0)
  289. 08224510 2080                 MOVE.L      D0,(A0)
  290. 08224512 4E75                 RTS
  291. 08224514 CAFE                 DC          $CAFE
  292. 08224516 BABE                 DC          $BABE»
  293. ^^^^^^^^ ^^^^^^^^^^^^^^       ^^^^^^^^^^^^^^^^^^^^^^
  294. Address  Instruction as Code  Instruction 
  295.          
  296. In other words, this is what the computer gets out of our little
  297. program. You should note that the       »CL7:LEA        $08224514,A0»
  298. moves exactly the address we wanted (The label Space) into a0.
  299. Now let the real fun begin.. (Escape).
  300.  
  301.  
  302.  
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309.  
  310.  
  311.  
  312.  
  313.  
  314.  
  315.  
  316.  
  317.  
  318.  
  319.  
  320.  
  321. Let's singlestepdebug our little
  322. program! Type:
  323.  
  324. »CL2:ad»
  325. , which means assemble/debug.
  326.  
  327. »CL1:Whoaa...» You're in the 'editor', and a
  328. black line is on the first line in the
  329. program. The contents of all registers
  330. are to the right.
  331. Now try pressing arrow down. And see,
  332. that d0 contains 0000001E.
  333. Do this until you've reached the
  334.  
  335. »CL4:move.w       d0,(a0)»
  336. , then press escape. Now examine
  337. what's on »CL1:Space» (h Space for the slow
  338. ones of you!!). It should definately
  339. not be CAFEBABE anymore! Great!
  340.  
  341. Finally, try just pressing
  342.  
  343. »CL2:a
  344. j»
  345.  
  346. And the entire program runs to the end
  347. »CL1:(until rts is encountered)». Now again
  348. examine »CL1:Space».
  349. This isn't very hard, I know!
  350. So know let's try generating a little
  351. table.
  352.  
  353.  
  354.  
  355.  
  356.  
  357.  
  358.  
  359. For this we need to learn a little bit
  360. about »CL1:branching». Let's introduce...
  361. »CL8:                             »BIG:The bxx command(s):
  362. »CL9:»SML:                    -----------------------------------------
  363. »CL0:The »CL1:bxx» is not ONE command, it's loads
  364. of commands. Let's make little
  365. example:
  366.  
  367. »CL4:Start: move.b    #$80,d1
  368.        move.b    #$80,d0
  369.        sub.b     d0,d1
  370.        beq       Stop
  371.        move.l    #$DEADBEEF,d0
  372. Stop:  rts
  373. »
  374. Before you run this program, let me
  375. ask you? Does d0 contain $DEADBEEF
  376. after this program has been run? :-)
  377.  
  378. OK... As you might hvae guessed, the
  379. »CL1:beq» command means »CL1:branch to the label
  380. Stop if the result was zero.»
  381.  
  382.  
  383. What actually happens is that the
  384. computer has got a »CL1:FLAGREGISTER»,
  385. containing information about the
  386. result of the last arithmetic
  387. operation.
  388. The flags are:
  389. »CL1:  Z (Zero)
  390.   N (Negative)
  391.   C (Carry)
  392.   V (oVerflow)»
  393. Explaining the use of this would bore
  394. you to death, I think. The only
  395. intersting things to say are perhaps
  396. that
  397. - the carry flag is set if an addition
  398. or multiplication hs a result bigger
  399. than can be in the register.
  400. - the V-flag is used on signed values.
  401. What is much more important is that the flags can be seen »CL1:BENEATH» the
  402. registers when »CL1:singlestepping». Try singlestepping the little program and
  403. watch the flags, as you move numbers into registers »CL1:(Note: $80.b = -$80),»
  404. and as you subtract. The many types of branching depend on the flags as this:
  405. »CL4:beq »CL5:(EQual):           » Z-flag set.
  406. bne »CL5:(Not Equal):       » Z-flag not set.
  407. bmi »CL5:(MInus):           » N-flag set.
  408. bpl »CL5:(PLus):            » N-flag not set.
  409. bcs »CL5:(Carry Set):       » C-flag set.
  410. bcc »CL5:(Carry Clear):     » C-flag not set.
  411. bvs »CL5:(oVerflow Set):    » V-flag set.
  412. bvc »CL5:(oVerflow Clear):  » V-flag not set.
  413. blt »CL5:(Less Than):       » V-flag the same as N-flag AND Z-flag not set.
  414. ble »CL5:(Less or Equal):   » V-flag the same as N-flag.
  415. bge »CL5:(Greater Than):    » V-flag not the same as N-flag AND Z-flag not set.
  416. bgt »CL5:(Greater or Equal):» V-flag not the same as N-flag
  417. blo »CL5:(LOwer):           » C-flag set.
  418. bls »CL5:(Lower or Same):   » C-flag set OR Z-flag set
  419. bhs »CL5:(Higher or Same):  » C-flag not set.
  420. bhi »CL5:(HIgher):          » C-flag not set OR Z-flag set
  421.  
  422.  
  423.  
  424.  
  425.  
  426.  
  427.  
  428.  
  429.  
  430.  
  431.  
  432.  
  433.  
  434.  
  435.  
  436.  
  437.  
  438.  
  439.  
  440.  
  441. »CL0:As you see, this can get rather
  442. complicated. Some of these commands
  443. are supposed to be used after the      
  444. »CL1:cmp»-command (compare). But for now,    
  445. let's just stick to »CL1:beq» and »CL1:bne». These 
  446. two can take us a long way! »CL1:They can   
  447. make us do loops!»
  448.  
  449. Before we begin, let me introduce you
  450. to a quite handy adressing mode:
  451. »CL4:       move.X       something,(aX)+
  452.        move.X       something,-(aX)
  453. »This is extremely neat, »CL1:as it will add/subtract either 1,2, or 4 to/from
  454. aX every time some data has been written to it.»
  455.  
  456. eg:»CL4:    add.w   d0,(a0)+»CL5: ; add d0.w to the location of a0 and then add 2 to a0
  457. »CL4:       sub.b   d1,-(a1)» ; subtract 1 from a1 and then
  458.                         ; subtract d1.b from the location of a1.
  459. »CL4:       move.l  #0,(a2)+ »; move $00000000 to the location of a2 and then
  460.                         ; add 4 to a2.
  461. »CL0:Our first decent program will make a
  462. square table (word-size) of the
  463. numbers 0-255. This isn't hardcoded,
  464. as I might confuse you a bit by smart
  465. optimizing!                             
  466.  
  467.  
  468.  
  469.  
  470.  
  471.  
  472.  
  473.  
  474.  
  475.  
  476.  
  477.  
  478.  
  479.  
  480.  
  481.                                »BIG:»CL8:Let's do it!:
  482. »SML:»CL9:-------------------------------------------------------------------------------
  483. »CL4:Squares:     move.w  #0,d0          »CL5: ; The number, we're at
  484. »CL4:             lea     SquareTable,a0  »; Find our table.
  485. »CL4:Loop:        move.w  d0,d1
  486.              mulu.w  d1,d1          » ; The square. Unsigned!
  487. »CL4:             move.w  d1,(a0)+   »     ; Move the square into the table,
  488.                                      ; then add 2 to a0
  489. »CL4:             add.w   #1,d0       »    ; The next number
  490. »CL4:             cmp.w   #256,d0      »   ; Are we finished?
  491. »CL4:             bne     Loop          »  ; If not, then loop.
  492. »CL4:             rts
  493. SquareTable: dcb.w   256,0      » ; Declare 256 words as 0
  494.  
  495.  
  496. »CL0:You should try to test if the program
  497. has done what it should by simply
  498. checking if the SquareTable consists
  499. the 256 squares after jumping. (a, j,
  500. h SquareTable).
  501.  
  502.  
  503.  
  504.  
  505.  
  506.  
  507.  
  508.  
  509.  
  510.  
  511.  
  512.  
  513.  
  514.  
  515.  
  516.  
  517. And by all means, try
  518. singlestepdebugging it and watch what
  519. happens in the registers!               
  520.  
  521. This concludes the first lesson of
  522. coding. I hope that some of you are
  523. inspired to make something out of
  524. coding now. Or at least to stay tuned
  525. here. Coding isn't as hard as it
  526. seems. Stay tuned for the next lesson,
  527. where we will go further into
  528. adressing and perhaps take a brief
  529. look at some optimizingmethods plus
  530. some more assembler-specific tricks.
  531.